---这个工具类用来解析properties 字符串 或者文件

local  _M={


    --[[
    命名空间: xstr
    作者: apache(email: hqwemail@gmail.com; website: http://hi.baidu.com/hqwfreefly)
    版本号: 0.2 (from 0.1)
    创建日期: 2010-10-17
    函数列表: trim, capitalize, count, startswith, endswith, expendtabs, isalnum, isalpha, isdigit, islower, isupper,
              join, lower, upper, partition, zfill, ljust, rjust, center, dir, help
    声明: 该软件为自由软件，遵循GPL协议。如果你需要为xstr增加函数，请在func_list中添加函数名，并在help函数中为其撰写帮助文档
    帮助: xstr:dir() 列出命名空间下的函数列表。xstr:help("func")查看func的帮助文档
    修改历史: 修改count函数的实现，使用gsub统计个数
--]]

        func_list = "trim, capitalize, count, startswith, endswith, expendtabs, isalnum, isalpha, isdigit, islower, isupper, join, lower, upper, partition, zfill, ljust, rjust, center, dir, help",
        --[[去除str中的所有空格。成功返回去除空格后的字符串，失败返回nil和失败信息]]
        trim = function (self, str)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            return (s:gsub("^%s*(.-)%s*$", "%1"))
            --str = string.gsub(str, " ", "")
            --return str
        end,
        --[[将str的第一个字符转化为大写字符。成功返回转换后的字符串，失败返回nil和失败信息]]
        capitalize = function(self, str)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            local ch = string.sub(str, 1, 1)
            local len = string.len(str)
            if ch < 'a' or ch > 'z' then
                return str
            end
            ch = string.char(string.byte(ch) - 32)
            if len == 1 then
                return ch
            else
                return ch .. string.sub(str, 2, len)
            end
        end,
        --[[统计str中substr出现的次数。from, to用于指定起始位置，缺省状态下from为1，to为字符串长度。成功返回统计个数，失败返回nil和失败信息]]
        count = function(self, str, substr, from, to)
            if str == nil or substr == nil then
                return nil, "the string or the sub-string parameter is nil"
            end
            from = from or 1
            if to == nil or to > string.len(str) then
                to = string.len(str)
            end
            local str_tmp = string.sub(str, from ,to)
            local n = 0
            _, n = string.gsub(str, substr, '')
            return n
        end,
        --[[判断str是否以substr开头。是返回true，否返回false，失败返回失败信息]]
        startswith = function(self, str, substr)
            if str == nil or substr == nil then
                return nil, "the string or the sub-stirng parameter is nil"
            end
            if string.find(str, substr) ~= 1 then
                return false
            else
                return true
            end
        end,
        --[[判断str是否以substr结尾。是返回true，否返回false，失败返回失败信息]]
        endswith = function(self, str, substr)
            if str == nil or substr == nil then
                return nil, "the string or the sub-string parameter is nil"
            end
            str_tmp = string.reverse(str)
            substr_tmp = string.reverse(substr)
            if string.find(str_tmp, substr_tmp) ~= 1 then
                return false
            else
                return true
            end
        end,
        --[[使用空格替换str中的制表符，默认空格个数为8。返回替换后的字符串]]
        expendtabs = function(self, str, n)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            n = n or 8
            str = string.gsub(str, "\t", string.rep(" ", n))
            return str
        end,
        --[[如果str仅由字母或数字组成，则返回true，否则返回false。失败返回nil和失败信息]]
        isalnum = function(self, str)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            local len = string.len(str)
            for i = 1, len do
                local ch = string.sub(str, i, i)
                if not ((ch >= 'a' and ch <= 'z') or (ch >= 'A' and ch <= 'Z') or (ch >= '0' and ch <= '9')) then
                    return false
                end
            end
            return true
        end,
        --[[如果str全部由字母组成，则返回true，否则返回false。失败返回nil和失败信息]]
        isalpha = function(self, str)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            local len = string.len(str)
            for i = 1, len do
                local ch = string.sub(str, i, i)
                if not ((ch >= 'a' and ch <= 'z') or (ch >= 'A' and ch <= 'Z')) then
                    return false
                end
            end
            return true
        end,
        --[[如果str全部由数字组成，则返回true，否则返回false。失败返回nil和失败信息]]
        isdigit = function(self, str)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            local len = string.len(str)
            for i = 1, len do
                local ch = string.sub(str, i, i)
                if ch < '0' or ch > '9' then
                    return false
                end
            end
            return true
        end,
        --[[如果str全部由小写字母组成，则返回true，否则返回false。失败返回nil和失败信息]]
        islower = function(self, str)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            local len = string.len(str)
            for i = 1, len do
                local ch = string.sub(str, i, i)
                if ch < 'a' or ch > 'z' then
                    return false
                end
            end
            return true
        end,
        --[[如果str全部由大写字母组成，则返回true，否则返回false。失败返回nil和失败信息]]
        isupper = function(self, str)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            local len = string.len(str)
            for i = 1, len do
                local ch = string.sub(str, i, i)
                if ch < 'A' or ch > 'Z' then
                    return false
                end
            end
            return true
        end,
        --[[使用substr连接str中的每个字符，返回连接后的新串。失败返回nil和失败信息]]
        join = function(self, str, substr)
            if str == nil or substr == nil then
                return nil, "the string or the sub-string parameter is nil"
            end
            local xlen = string.len(str) - 1
            if xlen == 0 then
                return str
            end
            local str_tmp = ""
            for i = 1, xlen do
                str_tmp = str_tmp .. string.sub(str, i, i) .. substr
            end
            str_tmp = str_tmp .. string.sub(str, xlen + 1, xlen + 1)
            return str_tmp
        end,
        --[[将str中的小写字母替换成大写字母，返回替换后的新串。失败返回nil和失败信息]]
        lower = function(self, str)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            local len = string.len(str)
            local str_tmp = ""
            for i = 1, len do
                local ch = string.sub(str, i, i)
                if ch >= 'A' and ch <= 'Z' then
                    ch = string.char(string.byte(ch) + 32)
                end
                str_tmp = str_tmp .. ch
            end
            return str_tmp
        end,
        --[[将str中的大写字母替换成小写字母，返回替换后的新串。失败返回nil和失败信息]]
        upper = function(self, str)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            local len = string.len(str)
            local str_tmp = ""
            for i = 1, len do
                local ch = string.sub(str, i, i)
                if ch >= 'a' and ch <= 'z' then
                    ch = string.char(string.byte(ch) - 32)
                end
                str_tmp = str_tmp .. ch
            end
            return str_tmp
        end,
        --[[将str以substr（从左向右查找）为界限拆分为3部分，返回拆分后的字符串。如果str中无substr则返回str, '', ''。失败返回nil和失败信息]]
        partition = function(self, str, substr)
            if str == nil or substr == nil then
                return nil, "the string or the sub-string parameter is nil"
            end
            local len = string.len(str)
            start_idx, end_idx = string.find(str, substr)
            if start_idx == nil or end_idx == len then
                return str, '', ''
            end
            return string.sub(str, 1, start_idx - 1), string.sub(str, start_idx, end_idx), string.sub(str, end_idx + 1, len)
        end,
        --[[在str前面补0，使其总长度达到n。返回补充后的新串，如果str长度已经超过n，则直接返回str。失败返回nil和失败信息]]
        zfill = function(self, str, n)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            if n == nil then
                return str
            end
            local format_str = "%0" .. n .. "s"
            return string.format(format_str, str)
        end,
        -----------------------------------------------------------------------------------------------------------------------------------------
        --[[设置str的位宽，默认的填充字符为空格。对齐方式为左对齐（rjust为右对齐，center为中间对齐）。返回设置后的字符串。失败返回nil和失败信息]]
        ljust = function(self, str, n, ch)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            ch = ch or " "
            n = tonumber(n) or 0
            local len = string.len(str)
            return string.rep(ch, n - len) .. str
        end,
        rjust = function(self, str, n, ch)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            ch = ch or " "
            n = tonumber(n) or 0
            local len = string.len(str)
            return str .. string.rep(ch, n - len)
        end,
        center = function(self, str, n, ch)
            if str == nil then
                return nil, "the string parameter is nil"
            end
            ch = ch or " "
            n = tonumber(n) or 0
            local len = string.len(str)
            rn_tmp = math.floor((n - len) / 2)
            ln_tmp = n - rn_tmp - len
            return string.rep(ch, rn_tmp) .. str .. string.rep(ch, ln_tmp)
        end,
        ------------------------------------------------------------------------------------------------------------------------------------------
        --[[显示xstr命名空间的所有函数名]]
        dir = function(self)
            print(self.func_list)
        end,
        --[[打印指定函数的帮助信息, 打印成功返回true，否则返回false]]
        help = function(self, fun_name)
            man = {
                ["trim"] = "xstr:trim(str) --> string | nil, err_msg\n  去除str中的所有空格，返回新串\n  print(xstr:trim(\"  hello wor ld \") --> helloworld",
                ["capitalize"] = "xstr:capitalize(str) --> string | nil, err_msg\n  将str的首字母大写，返回新串\n  print(xstr:capitalize(\"hello\") --> Hello",
                ["count"] = "xstr:count(str, substr [, from] [, to]) --> number | nil, err_msg\n  返回str中substr的个数, from和to用于指定统计范围, 缺省状态下为整个字符串\n  print(xstr:count(\"hello world!\", \"l\")) --> 3",
                ["startswith"] = "xstr:startswith(str, substr) --> boolean | nil, err_msg\n  判断str是否以substr开头, 是返回true，否返回false\n  print(xstr:startswith(\"hello world\", \"he\") --> true",
                ["endswith"] = "xstr:endswith(str, substr) --> boolean | nil, err_msg\n  判断str是否以substr结尾, 是返回true, 否返回false\n  print(xstr:endswith(\"hello world\", \"d\")) --> true",
                ["expendtabs"] = "xstr:expendtabs(str, n) --> string | nil, err_msg\n  将str中的Tab制表符替换为n格空格，返回新串。n默认为8\n  print(xstr:expendtabs(\"hello  world\")) --> hello        world",
                ["isalnum"] = "xstr:isalnum(str) --> boolean | nil, err_msg\n  判断str是否仅由字母和数字组成，是返回true，否返回false\n  print(xstr:isalnum(\"hello world:) 123\")) --> false",
                ["isalpha"] = "xstr:isalpha(str) --> boolean | nil, err_msg\n  判断str是否仅由字母组成，是返回true，否返回false\n  print(xstr:isalpha(\"hello WORLD\")) --> true",
                ["isdigit"] = "xstr:isdigit(str) --> boolean | nil, err_msg\n  判断str是否仅由数字组成，是返回true，否返回false\n  print(xstr:isdigit(\"0123456789\")) --> true",
                ["islower"] = "xstr:islower(str) --> boolean | nil, err_msg\n  判断str是否全部由小写字母组成，是返回true，否返回false\n  print(xstr:islower(\"hello world\")) --> true",
                ["isupper"] = "xstr:isupper(str) --> boolean | nil, err_msg\n  判断str是否全部由大写字母组成，是返回true，否返回false\n  print(xstr:isupper(\"HELLO WORLD\")) --> true",
                ["join"] = "xstr:join(str, substr) --> string | nil, err_msg\n  使用substr连接str中的每个元素，返回新串\n  print(xstr:join(\"hello\", \"--\")) --> h--e--l--l--o",
                ["lower"] = "xstr:lower(str) --> string | nil, err_msg\n  将str中的大写字母小写化，返回新串\n  print(xstr:lower(\"HeLLo WORld 2010\")) --> hello wold 2010",
                ["upper"] = "xstr:upper(str) --> string | nil, err_msg\n  将str中的小写字母大写化，返回新串\n  print(xstr:upper(\"hello world 2010\")) --> HELLO WORLD 2010",
                ["partition"] = "xstr:partition(str, substr) --> string, string, string | nil, err_msg\n  将str按照substr为界限拆分为3部分，返回拆分后的字符串\n  print(xstr:partition(\"hello*world\", \"wo\")) --> hello*  wo  rld",
                ["zfill"] = "xstr:zfill(str, n) --> string | nil, err_msg\n  在str前补0，使其总长度为n。返回新串\n  print(xstr:zfill(\"100\", 5)) --> 00100",
                ["ljust"] = "xstr:ljust(str, n, ch) --> string | nil, err_msg\n  按左对齐方式，使用ch补充str，使其位宽为n。ch默认为空格，n默认为0\n  print(xstr:ljust(\"hello\", 10, \"*\")) --> *****hello"
            }

        end
}
 function _M.split(s,sep)
    local sep,fields = sep or ":",{}
    local pattern = string.format("([^%s]+)",sep)

    s:gsub(pattern,function(c) fields[#fields+1]=c end)

    return fields;

end

function _M.trim(s)
    print("trim s"..s)

    return string.gsub(s, "^%s*(.-)%s*$","%1")


    --return (s:gusb("^%s*(.-)%s*$","%1"))

end

function _M.isIp(ipStr)

        if type(ipStr) ~= "string" then
            return false;
        end

        --判断长度
        local len = string.len(ipStr);
        if len < 7 or len > 15 then --长度不对
            return false;
        end

        --判断出现的非数字字符
        local point = string.find(ipStr, "%p", 1); --字符"."出现的位置
        local pointNum = 0; --字符"."出现的次数 正常ip有3个"."
        while point ~= nil do
            if string.sub(ipStr, point, point) ~= "." then --得到非数字符号不是字符"."
                return false;
            end
            pointNum = pointNum + 1;
            point = string.find(ipStr, "%p", point + 1);
            if pointNum > 3 then
                return false;
            end
        end
        if pointNum ~= 3 then --不是正确的ip格式

            return false;
        end

        --判断数字对不对
        local num = {};
        for w in string.gmatch(ipStr, "%d+") do
            num[#num + 1] = w;
            local kk = tonumber(w);
            if kk == nil or kk > 255 then --不是数字或超过ip正常取值范围了
                return false;
            end
        end

        if #num ~= 4 then --不是4段数字
            return false;
        end

        return true;


end

function _M:isIpStr(ipStr)
    local regx ="%d*.%d*.%d*.%d."
    regx ="%d*.%d*.%d*.%d*"

    for w in string.gmatch(ipStr, regx) do
        return true

    end
    return false
end



--
--local a = _M:endswith("asdfasdf.lua","123.lua")
--print(a)
return _M;





